/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.latesis.movil.service;

import com.latesis.bean.AlertaBean;
import com.latesis.bean.AlertaEnviadaBean;
import com.latesis.bean.AsignacionServicioBean;
import com.latesis.bean.ChoferBean;
import com.latesis.bean.DetalleServicioBean;
import com.latesis.bean.DireccionClienteBean;
import com.latesis.bean.EstadoBean;
import com.latesis.bean.MarcacionBean;
import com.latesis.bean.MensajeBean;
import com.latesis.bean.MovilBean;
import com.latesis.bean.ServicioBean;
import com.latesis.bean.TarifaBean;
import com.latesis.bean.TrackingBean;
import com.latesis.bean.ZonaBean;
import com.latesis.dao.AlertaDAO;
import com.latesis.dao.AlertaEnviadaDAO;
import com.latesis.dao.AsignacionServicioDAO;
import com.latesis.dao.ChoferDAO;
import com.latesis.dao.ClienteDAO;
import com.latesis.dao.DetalleServicioDAO;
import com.latesis.dao.DetalleTarifaDAO;
import com.latesis.dao.DireccionClienteDAO;
import com.latesis.dao.EstadoDAO;
import com.latesis.dao.GrupoDAO;
import com.latesis.dao.MarcacionDAO;
import com.latesis.dao.MensajeDAO;
import com.latesis.dao.MovilDAO;
import com.latesis.dao.OperadorDAO;
import com.latesis.dao.PropietarioDAO;
import com.latesis.dao.PuntoGeocercaDAO;
import com.latesis.dao.ServicioDAO;
import com.latesis.dao.TarifaDAO;
import com.latesis.dao.TrackingDAO;
import com.latesis.dao.ZonaDAO;
import com.latesis.movil.bean.MAlertaBean;
import com.latesis.movil.bean.MAlertaEnviadaBean;
import com.latesis.movil.bean.MChoferBean;
import com.latesis.movil.bean.MDetalleServicioBean;
import com.latesis.movil.bean.MEstadoBean;
import com.latesis.movil.bean.MMensajeBean;
import com.latesis.movil.bean.MMovilBean;
import com.latesis.movil.bean.MPuntoGPSBean;
import com.latesis.movil.bean.MServicioBean;
import com.latesis.movil.bean.MTarifaBean;
import com.latesis.movil.bean.MZonaBean;
import com.latesis.movil.dto.ConfirmacionServicioRequestDTO;
import com.latesis.movil.dto.ConfirmacionServicioResponseDTO;
import com.latesis.movil.dto.DTOConstantes;
import com.latesis.movil.dto.EnvioBackgroundRequestDTO;
import com.latesis.movil.dto.EnvioBackgroundResponseDTO;
import com.latesis.movil.dto.GPSTrackingRequestDTO;
import com.latesis.movil.dto.GPSTrackingResponseDTO;
import com.latesis.movil.dto.LoginRequestDTO;
import com.latesis.movil.dto.LoginResponseDTO;
import com.latesis.movil.dto.MarcacionRequestDTO;
import com.latesis.movil.dto.MarcacionResponseDTO;
import com.latesis.movil.dto.ResultadoBeanDTO;
import com.latesis.movil.dto.SincronizacionRequestDTO;
import com.latesis.movil.dto.SincronizacionResponseDTO;
import com.latesis.movil.util.MovilWrapper;
import com.latesis.prueba.PruebaService;
import com.latesis.util.Constantes;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 *
 * @author Diego
 */
public class MovilServiceImpl implements MovilService{
    
    private static final Logger logger = Logger.getLogger(MovilServiceImpl.class);
    
    private MovilDAO movilDAO;
    private ChoferDAO choferDAO;
    private PropietarioDAO propietarioDAO;
    private TrackingDAO trackingDAO;
    private GrupoDAO grupoDAO;
    private MensajeDAO mensajeDAO;
    private AlertaDAO alertaDAO;
    private AlertaEnviadaDAO alertaEnviadaDAO;
    private ZonaDAO zonaDAO;
    private ClienteDAO clienteDAO;
    private DireccionClienteDAO direccionClienteDAO;
    private EstadoDAO estadoDAO;
    private ServicioDAO servicioDAO;
    private DetalleServicioDAO detalleServicioDAO;
    private OperadorDAO operadorDAO;
    private TarifaDAO tarifaDAO;
    private DetalleTarifaDAO detalleTarifaDAO;
    private PuntoGeocercaDAO puntoGeocercaDAO;
    private MarcacionDAO marcacionDAO;
    private AsignacionServicioDAO asignacionServicioDAO;
    
    @Transactional(propagation=Propagation.REQUIRED)
    public LoginResponseDTO login(LoginRequestDTO request){        
        logger.info(">>  login");        
        LoginResponseDTO response=new LoginResponseDTO();
        
        ChoferBean chofer=choferDAO.login(request.getLogin(), request.getPassword());
        if(chofer!=null){
            
            //validar el estado de la movil
            
            response.setResultadoLogin(DTOConstantes.RESULTADO_LOGIN_OK);
            response.setChofer(MovilWrapper.toMChofer(chofer));
            
            ArrayList<MMovilBean> moviles=new ArrayList<MMovilBean>();
            for(MovilBean movil:chofer.getMoviles()){
                
                //validar si esta ocupada
                
                moviles.add(MovilWrapper.toMMovil(movil));
            }
            response.setListaMoviles(moviles);
            
        }else{
            response.setResultadoLogin(DTOConstantes.RESULTADO_LOGIN_INCORRECTO);
        }
        
        return response;
    }

    public void cambiarEstadoMovil(long idChofer, long idMovil) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public MarcacionResponseDTO marcacion(MarcacionRequestDTO request) {
        logger.info(">>  marcacion"); 
        MarcacionResponseDTO response=new MarcacionResponseDTO();
        try{
            ChoferBean choferBusqueda=new ChoferBean();
            choferBusqueda.setId(request.getIdChofer());
            ChoferBean chofer=choferDAO.buscar(choferBusqueda);
            
            MovilBean movilBusqueda=new MovilBean();
            movilBusqueda.setId(request.getIdMovil());
            MovilBean movil=movilDAO.buscar(movilBusqueda);
            
            if(request.getTipoMarcacion()==DTOConstantes.TIPO_MARCACION_ENTRADA){
                //ENTRADA
                MarcacionBean marcacion=new MarcacionBean();
                marcacion.setChofer(chofer);
                marcacion.setMovil(movil);
                marcacion.setLatIngreso(request.getLatitud());
                marcacion.setLonIngreso(request.getLongitud());
                marcacion.setTelefono(request.getTelefono());
                marcacion.setFechaIngreso(request.getFecha());           
                marcacion.setEstadoAtencion(Constantes.ESTADO_ATENCION_LIBRE);
                marcacion.setGcmRegId(request.getGcmRegId());
                 logger.info(">>  1"); 
                marcacionDAO.guardar(marcacion);
             
                 logger.info(">>  2"); 
                movil.setUltimaMarcacion(marcacion);
                movil.getMarcaciones().add(marcacion);
                movilDAO.guardar(movil);

                 logger.info(">>  3"); 
                chofer.setUltimaMarcacion(marcacion);
                chofer.getMarcaciones().add(marcacion);
                choferDAO.guardar(chofer);
                
            }else{
                //SALIDA
                MarcacionBean marcacion=chofer.getUltimaMarcacion();
                marcacion.setLatSalida(request.getLatitud());
                marcacion.setLonSalida(request.getLongitud());
                marcacion.setFechaSalida(request.getFecha());
                marcacionDAO.guardar(marcacion);               
                
            }
            
        }catch(Exception e){
            logger.error(e.getMessage());
            response.setResultadoMarcacion(DTOConstantes.RESULTADO_MARCACION_ERROR);
            return response;
        }
        
        response.setResultadoMarcacion(DTOConstantes.RESULTADO_MARCACION_OK);
        
        return response;
    }
    
    @Transactional(propagation=Propagation.REQUIRED)
    public SincronizacionResponseDTO sincronizacion(SincronizacionRequestDTO request) {
        logger.info(">>  sincronizar"); 
        SincronizacionResponseDTO response=new SincronizacionResponseDTO();
        try{
            logger.info(">>  obtener datos");                                                 
            
            if(request.isEstados()){
                logger.info(">>  estados"); 
                List<EstadoBean> estados=estadoDAO.buscarMovil();
                ArrayList<MEstadoBean> mEstados=new ArrayList<MEstadoBean>();
                for(EstadoBean bean:estados){
                    mEstados.add(MovilWrapper.toMEstado(bean));
                }
                response.setListaEstados(mEstados);
            }
            
            if(request.isAlertas()){
                logger.info(">>  alertas"); 
                List<AlertaBean> alertas=alertaDAO.buscarTodos();
                ArrayList<MAlertaBean> mAlertas=new ArrayList<MAlertaBean>();
                for(AlertaBean bean:alertas){
                    mAlertas.add(MovilWrapper.toMAlerta(bean));
                }
                response.setListaAlertas(mAlertas);
            }
            
            if(request.isZonas()){
                logger.info(">>  zonas"); 
                List<ZonaBean> zonas=zonaDAO.buscarTodos();
                ArrayList<MZonaBean> mZonas=new ArrayList<MZonaBean>();
                for(ZonaBean bean:zonas){
                    mZonas.add(MovilWrapper.toMZona(bean));
                }
                response.setListaZonas(mZonas);
            }
            
            if(request.isTarifas()){
                logger.info(">>  tarifas"); 
                List<TarifaBean> tarifas=tarifaDAO.buscarTodos();            
                ArrayList<MTarifaBean> mTarifas=new ArrayList<MTarifaBean>();
                for(TarifaBean bean:tarifas){
                    mTarifas.add(MovilWrapper.toMTarifa(bean));
                }
                response.setListaTarifas(mTarifas);
            }
            
            if(request.isMensajes()){
                logger.info(">>  mensajes"); 
                List<MensajeBean> mensajes=mensajeDAO.buscarNuevos(request.getIdChofer(), request.getMaximoIdBDMensajes());
                ArrayList<MMensajeBean> mMensajes=new ArrayList<MMensajeBean>();
                for(MensajeBean bean:mensajes){
                    mMensajes.add(MovilWrapper.toMMensaje(bean,request.getIdChofer()));
                }
                response.setListaMensajes(mMensajes);                
            }
            
            if(request.isServicios()){
                logger.info(">>  servicios"); 
                //servicios que ya pertenecen a la movil y chofer
                List<ServicioBean> servicios=servicioDAO.buscarPendientes(request.getIdChofer(), request.getIdMovil());
                //servicios que han sido enviados a un grupo y aun ninguno ha confirmado
                List<ServicioBean> serviciosAsignadosAGrupo=servicioDAO.buscarAsignados(request.getIdChofer(), request.getIdMovil());
                servicios.addAll(serviciosAsignadosAGrupo);
                
                ArrayList<MServicioBean> mServicios=new ArrayList<MServicioBean>();
                for(ServicioBean bean:servicios){
                    mServicios.add(MovilWrapper.toMServicio(bean));
                }
                response.setListaServicios(mServicios);                
            }
            
        }catch(Exception e){
            logger.error(e.getMessage());
            response.setResultadoSincronizacion(DTOConstantes.RESULTADO_SINCRONIZACION_ERROR);
            return response;
        }
        
        response.setResultadoSincronizacion(DTOConstantes.RESULTADO_SINCRONIZACION_OK);
        
        return response;
    }

    
    
    @Transactional(propagation=Propagation.REQUIRED)
    public EnvioBackgroundResponseDTO pendientes(EnvioBackgroundRequestDTO request) {
        logger.info(">>  pendientes"); 
        EnvioBackgroundResponseDTO response=new EnvioBackgroundResponseDTO();

        if (request.getListaAlertasEnviadas()!=null && !request.getListaAlertasEnviadas().isEmpty()){
            ArrayList<ResultadoBeanDTO> resultados=new ArrayList<ResultadoBeanDTO>();
            for(MAlertaEnviadaBean alertaMovil:request.getListaAlertasEnviadas()){
                ResultadoBeanDTO r=new ResultadoBeanDTO();
                r.setIdMovil(alertaMovil.getIdMovil());
                try{
                    AlertaEnviadaBean alertaBD=new AlertaEnviadaBean();
                    
                    AlertaBean tipoAlerta=new AlertaBean();
                    tipoAlerta.setId(alertaMovil.getIdAlertaBD());
                    alertaBD.setAlerta(tipoAlerta);
                    
                    ChoferBean chofer=new ChoferBean();
                    chofer.setId(alertaMovil.getIdChoferBD());
                    alertaBD.setChofer(chofer);
                    
                    MovilBean movil=new MovilBean();
                    movil.setId(alertaMovil.getIdMovilBD());
                    alertaBD.setMovil(movil);
                    
                    alertaBD.setFechaEnvio(alertaMovil.getFechaEnvio());
                    alertaBD.setLatitud(alertaMovil.getLatitud());
                    alertaBD.setLongitud(alertaMovil.getLongitud());
                    alertaBD.setEstadoAlerta(Constantes.ESTADO_ALERTA_PENDIENTE);
                    
                    alertaEnviadaDAO.guardar(alertaBD);
                    r.setIdBD(alertaBD.getId());
                }catch(Exception e){                    
                    logger.error(e.getMessage());
                    r.setResultado(ResultadoBeanDTO.ERROR);
                    resultados.add(r);
                    continue;
                }
                
                r.setResultado(ResultadoBeanDTO.OK);
                resultados.add(r);
                
            }
            response.setResultadoListaAlertasEnviadas(resultados);
        }
        
        
        if (request.getListaServiciosEnviados()!=null && !request.getListaServiciosEnviados().isEmpty()){
            ArrayList<ResultadoBeanDTO> resultados=new ArrayList<ResultadoBeanDTO>();
            for(MServicioBean servicioMovil:request.getListaServiciosEnviados()){
                ResultadoBeanDTO r=new ResultadoBeanDTO();
                r.setIdMovil(servicioMovil.getIdMovil());
                r.setListaSubResultados(new ArrayList<ResultadoBeanDTO>());
                try{
                    
                    logger.info(">> pendientes servicio - 1");
                    ServicioBean servicioBD=new ServicioBean();
                    
                    servicioBD.setId(servicioMovil.getIdBD());
                    
                    servicioBD = servicioDAO.buscar(servicioBD);
                    
                    logger.info(">> pendientes servicio - 2");
                    //recorrer todos los detalles y validar que el nuevo no haya sido registrado
                    for(MDetalleServicioBean detalleServicioMovil: servicioMovil.getDetallesServicio()){
                        logger.info(">> pendientes servicio - 3");
                        boolean yaRegistrado=false;
                        boolean noEsUltimoEstado=false;
                        for(DetalleServicioBean detalleServicioBD: servicioBD.getDetallesServicio()){
                            logger.info(">> pendientes servicio - 4");
                            if(detalleServicioBD.getFechaRegistro().compareTo(detalleServicioMovil.getFechaRegistro())==0){
                                logger.info(">> pendientes servicio - 5");
                                yaRegistrado=true;
                            }                            
                            logger.info(">> pendientes servicio - 6");
                            if(detalleServicioBD.getFechaRegistro().compareTo(detalleServicioMovil.getFechaRegistro())>=0){
                                logger.info(">> pendientes servicio - 7");
                                noEsUltimoEstado=true;
                            }                            
                        }
                        logger.info(">> pendientes servicio - 8");
                        if(!yaRegistrado){
                            logger.info(">> pendientes servicio - 9");
                            DetalleServicioBean detalle=new DetalleServicioBean();
                            
                            EstadoBean estado=new EstadoBean();
                            estado.setId(detalleServicioMovil.getIdEstado());
                            estado=estadoDAO.buscar(estado);
                            
                            logger.info(">> pendientes servicio - 10");
                            
                            detalle.setEstadoServicio(estado);
                            detalle.setFechaRegistro(detalleServicioMovil.getFechaRegistro());
                            detalle.setLatitud(detalleServicioMovil.getLatitud());
                            detalle.setLongitud(detalleServicioMovil.getLongitud());
                            detalle.setOrigen(Constantes.ORIGEN_MOVIL);
                            detalle.setServicio(servicioBD);                                                     
                            
                            detalleServicioDAO.guardar(detalle);
                            
                            logger.info(">> pendientes servicio - 11");
                            servicioBD.getDetallesServicio().add(detalle);
                            //ver si el servicio necesita atencion
                            if(estado.getAlerta().booleanValue()){
                                servicioBD.setNecesitaAtencion(true);
                            }
                            
                            logger.info(">> pendientes servicio - 12");
                            if(!noEsUltimoEstado){
                                servicioBD.setUltimoEstadoServicio(estado);
                                
                                logger.info(">> pendientes servicio - 13");
                                //si es un estado de finalizacion dar por finalizado el servicio
                                if(Constantes.TIPO_ESTADO_FINALIZACION_COMPLETO.equals(estado.getTipo()) || 
                                        Constantes.TIPO_ESTADO_FINALIZACION_COMPLETO.equals(estado.getTipo())){
                                    servicioBD.setFinalizado(true);
                                }                                
                                
                                logger.info(">> pendientes servicio - 14");
                                //actualizar si necesita atencion
                                if(Constantes.TIPO_ESTADO_ATENCION.equals(estado.getTipo())){
                                    servicioBD.setNecesitaAtencion(true);
                                }                   
                                                                                                
                            }
                            logger.info(">> pendientes servicio - 15");
                            //servicioDAO.guardar(servicioBD);
                            logger.info(">> pendientes servicio - 16");
                            ResultadoBeanDTO r2=new ResultadoBeanDTO();
                            logger.info(">> pendientes servicio - 16a");
                            r2.setIdBD(detalle.getId());
                            logger.info(">> pendientes servicio - 16b");
                            r2.setIdMovil(detalleServicioMovil.getIdMovil());
                            logger.info(">> pendientes servicio - 16c");
                            r2.setResultado(ResultadoBeanDTO.OK);
                            logger.info(">> pendientes servicio - 16d");
                            r.getListaSubResultados().add(r2);      
                            logger.info(">> pendientes servicio - 17");
                        }
                    }
                    
                    //ver si hay que actualizar el gps de la direccion
                    if(servicioBD.getDireccion()!=null){
                        if(servicioBD.getDireccion().getLatitud()!=servicioMovil.getDireccionLatitud() ||
                                servicioBD.getDireccion().getLongitud()!=servicioMovil.getDireccionLongitud()){
                            DireccionClienteBean dir=servicioBD.getDireccion();
                            dir.setLatitud(servicioMovil.getDireccionLatitud());
                            dir.setLongitud(servicioMovil.getDireccionLongitud());
                            direccionClienteDAO.guardar(dir);
                        }
                    }
                                                                    
                    logger.info(">> pendientes servicio - 18");
                    servicioDAO.guardar(servicioBD);
                    r.setIdBD(servicioBD.getId());
                    
                }catch(Exception e){                    
                    logger.error(e.getMessage());
                    r.setResultado(ResultadoBeanDTO.ERROR);
                    resultados.add(r);
                    continue;
                }
                
                r.setResultado(ResultadoBeanDTO.OK);
                resultados.add(r);
                
            }
            response.setResultadoListaServiciosEnviados(resultados);
        }
        
        
        
                        
        return response;
    }

    
    @Transactional(propagation=Propagation.REQUIRED)
    public GPSTrackingResponseDTO gpstracking(GPSTrackingRequestDTO request) {        
        logger.info(">>  gpstracking"); 
        GPSTrackingResponseDTO response=new GPSTrackingResponseDTO();
        
        try{
            MovilBean movilQry=new MovilBean();
            movilQry.setId(request.getIdMovil());
            MovilBean movil=movilDAO.buscar(movilQry);
            for(MPuntoGPSBean punto:request.getListaPuntos()){
                TrackingBean tracking=new TrackingBean();
                tracking.setMovil(movil);
                tracking.setDireccion(punto.getDireccion());
                tracking.setLatitud(punto.getLatitud());
                tracking.setLongitud(punto.getLongitud());
                tracking.setPrecisionn(punto.getPrecision());
                tracking.setVelocidad(punto.getVelocidad());
                tracking.setFechaRegistro(punto.getFecha());
                trackingDAO.guardar(tracking);
                
                if(movil.getUltimoTracking()==null || (movil.getUltimoTracking().getFechaRegistro().compareTo(tracking.getFechaRegistro())<0)){
                    movil.setUltimoTracking(tracking);
                    movilDAO.guardar(movil);
                }
            }
        }catch(Exception e){
            logger.error(e.getMessage());
            response.setResultadoTracking(DTOConstantes.RESULTADO_GPS_TRACKING_ERROR);
            return response;
        }
        response.setResultadoTracking(DTOConstantes.RESULTADO_GPS_TRACKING_OK);
        return response;
    }
    
    
    @Transactional(propagation=Propagation.REQUIRED)
    public ConfirmacionServicioResponseDTO confirmacionServicio(ConfirmacionServicioRequestDTO request) {
        logger.info(">>  confirmacionServicio");         
        
        ConfirmacionServicioResponseDTO response= new ConfirmacionServicioResponseDTO();
        /*
        try{
            //if(Constantes.TIPO_CONFIRMACION_SI.equals(request.getTipoConfirmacion())){
            if(request.isConfirma()){
                //validar que nadie haya confirmado antes
                ServicioBean servicioQry=new ServicioBean();
                servicioQry.setId(request.getIdServicio());
                
                ServicioBean servicio=servicioDAO.buscar(servicioQry);
                if (servicio.getMovil()==null && servicio.getChofer()==null){
                    //actualizar servicio con los datos del que confirma    
                    ChoferBean choferQry=new ChoferBean();
                    choferQry.setId(request.getIdChofer());                    
                    //ChoferBean chofer=choferDAO.buscar(choferQry);
                            
                    MovilBean movilQry=new MovilBean();
                    movilQry.setId(request.getIdMovil());
                    //MovilBean movil=movilDAO.buscar(movilQry);
                    
                    servicio.setChofer(choferQry);
                    servicio.setMovil(movilQry);
                    //servicio.setGrupoAsignacion(null);
                    
                    //limpiar la tabla de asignaciones
                    
                    //agregar detalle
                    MDetalleServicioBean detalleServicioMovil=request.getDetalleServicio();
                    DetalleServicioBean detalle=new DetalleServicioBean();
                            
                    EstadoBean estado=new EstadoBean();
                    estado.setId(detalleServicioMovil.getIdEstado());
                    estado=estadoDAO.buscar(estado);
                                                
                    detalle.setEstadoServicio(estado);
                    detalle.setFechaRegistro(detalleServicioMovil.getFechaRegistro());
                    detalle.setLatitud(detalleServicioMovil.getLatitud());
                    detalle.setLongitud(detalleServicioMovil.getLongitud());
                    detalle.setOrigen(detalleServicioMovil.getOrigen());
                    detalle.setServicio(servicio);
                            
                    servicio.getDetallesServicio().add(detalle);
                                                       
                    servicioDAO.guardar(servicio);
                                                            
                    response.setResultadoConfirmacion(DTOConstantes.RESULTADO_CONFIRMACION_OK);
                }else{
                    response.setResultadoConfirmacion(DTOConstantes.RESULTADO_CONFIRMACION_YA_CONFIRMADO);
                }
                
            }else{
                //no hacer nada porque no estamos registrando los rechazos
            }
        }catch(Exception e){
            logger.error(e.getMessage());
            response.setResultadoConfirmacion(DTOConstantes.RESULTADO_CONFIRMACION_ERROR);
        }
                */
        
        try{
            
            //AsignacionServicioBean asignacionQry=new AsignacionServicioBean();
            //asignacionQry.setId(request.getIdAsignacion());
            AsignacionServicioBean asignacion=asignacionServicioDAO.buscar(request.getIdServicio(),request.getIdChofer(),request.getIdMovil());
                
            if(Constantes.TIPO_CONFIRMACION_SI.equals(request.getRespuestaConfirmacion())){                                                                                
                ServicioBean servicio=asignacion.getServicio();
                if (servicio.getMovil()==null && servicio.getChofer()==null){
                    //actualizar servicio con los datos del que confirma                        
                    servicio.setChofer(asignacion.getChofer());
                    servicio.setMovil(asignacion.getMovil());
                    servicioDAO.guardar(servicio);
                                                                              
                    response.setResultadoConfirmacion(DTOConstantes.RESULTADO_CONFIRMACION_OK);
                }else{
                    response.setResultadoConfirmacion(DTOConstantes.RESULTADO_CONFIRMACION_YA_CONFIRMADO);
                }
                
            }else{
                response.setResultadoConfirmacion(DTOConstantes.RESULTADO_CONFIRMACION_OK);
            }
            
            //actualizar tabla de asignaciones
            asignacion.setRespuesta(request.getRespuestaConfirmacion());
            asignacion.setFechaRespuesta(request.getFechaRespuesta());
            asignacion.setLatitud(request.getLatitud());
            asignacion.setLongitud(request.getLongitud());
            asignacionServicioDAO.guardar(asignacion);
            
        }catch(Exception e){
            logger.error(e.getMessage());
            response.setResultadoConfirmacion(DTOConstantes.RESULTADO_CONFIRMACION_ERROR);
        }
        
        return response;
    }
    
    
    
    
    
    
    public void setMovilDAO(MovilDAO movilDAO) {
        this.movilDAO = movilDAO;
    }

    public void setChoferDAO(ChoferDAO choferDAO) {
        this.choferDAO = choferDAO;
    }

    public void setPropietarioDAO(PropietarioDAO propietarioDAO) {
        this.propietarioDAO = propietarioDAO;
    }

    public void setTrackingDAO(TrackingDAO trackingDAO) {
        this.trackingDAO = trackingDAO;
    }

    public void setGrupoDAO(GrupoDAO grupoDAO) {
        this.grupoDAO = grupoDAO;
    }

    public void setMensajeDAO(MensajeDAO mensajeDAO) {
        this.mensajeDAO = mensajeDAO;
    }

    public void setAlertaDAO(AlertaDAO alertaDAO) {
        this.alertaDAO = alertaDAO;
    }

    public void setAlertaEnviadaDAO(AlertaEnviadaDAO alertaEnviadaDAO) {
        this.alertaEnviadaDAO = alertaEnviadaDAO;
    }

    public void setZonaDAO(ZonaDAO zonaDAO) {
        this.zonaDAO = zonaDAO;
    }

    public void setClienteDAO(ClienteDAO clienteDAO) {
        this.clienteDAO = clienteDAO;
    }

    public void setDireccionClienteDAO(DireccionClienteDAO direccionClienteDAO) {
        this.direccionClienteDAO = direccionClienteDAO;
    }

    public void setEstadoDAO(EstadoDAO estadoDAO) {
        this.estadoDAO = estadoDAO;
    }

    public void setServicioDAO(ServicioDAO servicioDAO) {
        this.servicioDAO = servicioDAO;
    }

    public void setDetalleServicioDAO(DetalleServicioDAO detalleServicioDAO) {
        this.detalleServicioDAO = detalleServicioDAO;
    }

    public void setOperadorDAO(OperadorDAO operadorDAO) {
        this.operadorDAO = operadorDAO;
    }

    public void setTarifaDAO(TarifaDAO tarifaDAO) {
        this.tarifaDAO = tarifaDAO;
    }

    public void setDetalleTarifaDAO(DetalleTarifaDAO detalleTarifaDAO) {
        this.detalleTarifaDAO = detalleTarifaDAO;
    }

    public void setPuntoGeocercaDAO(PuntoGeocercaDAO puntoGeocercaDAO) {
        this.puntoGeocercaDAO = puntoGeocercaDAO;
    }

    public void setMarcacionDAO(MarcacionDAO marcacionDAO) {
        this.marcacionDAO = marcacionDAO;
    }

    public void setAsignacionServicioDAO(AsignacionServicioDAO asignacionServicioDAO) {
        this.asignacionServicioDAO = asignacionServicioDAO;
    }

    

    

    
    
    

}
